{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding PlaNet (Deep Planning Network): A Complete Guide\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction: Model-Based RL with Latent Dynamics](#introduction)\n",
    "- [What is PlaNet?](#what-is-planet)\n",
    "  - [Core Idea: Learning Dynamics & Planning in Latent Space](#core-idea)\n",
    "- [Why PlaNet? The Power of Learned Models & Planning](#why-planet)\n",
    "- [Where and How PlaNet is Used](#where-and-how-planet-is-used)\n",
    "- [Mathematical Foundation of PlaNet](#mathematical-foundation-of-planet)\n",
    "  - [Latent Dynamics Model (Conceptual)](#latent-dynamics-model-conceptual)\n",
    "    - [Transition Model](#transition-model)\n",
    "    - [Reward Model](#reward-model)\n",
    "    - [Observation/Representation Model (Simplified)](#observationrepresentation-model-simplified)\n",
    "  - [Model Training Objective](#model-training-objective)\n",
    "  - [Planning with the Model: Cross-Entropy Method (CEM)](#planning-with-the-model-cross-entropy-method-cem)\n",
    "  - [Action Selection](#action-selection)\n",
    "- [Step-by-Step Explanation of PlaNet](#step-by-step-explanation-of-planet)\n",
    "- [Key Components of PlaNet](#key-components-of-planet)\n",
    "  - [World Model (Dynamics Model)](#world-model-dynamics-model)\n",
    "  - [Replay Buffer (Sequence-Based)](#replay-buffer-sequence-based)\n",
    "  - [Model Training Procedure](#model-training-procedure)\n",
    "  - [Planner (CEM)](#planner-cem)\n",
    "  - [Action Execution](#action-execution)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Pendulum Environment](#practical-example-pendulum-environment)\n",
    "  - [Why Pendulum for this PlaNet Example?](#why-pendulum-for-this-planet-example)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Continuous Environment (Gymnasium)](#creating-the-continuous-environment-gymnasium)\n",
    "- [Implementing the PlaNet Algorithm](#implementing-the-planet-algorithm)\n",
    "  - [Defining the Dynamics Model (Simplified)](#defining-the-dynamics-model-simplified)\n",
    "  - [Defining the Sequence Replay Buffer](#defining-the-sequence-replay-buffer)\n",
    "  - [Implementing the CEM Planner](#implementing-the-cem-planner)\n",
    "  - [Model Training Function](#model-training-function)\n",
    "- [Running the PlaNet Algorithm](#running-the-planet-algorithm)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Initialization](#initialization)\n",
    "  - [Training Loop](#training-loop)\n",
    "- [Visualizing the Learning Process](#visualizing-the-learning-process)\n",
    "- [Analyzing the Learned Policy (Testing)](#analyzing-the-learned-policy-testing)\n",
    "- [Common Challenges and Extensions of PlaNet](#common-challenges-and-extensions-of-planet)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## Introduction: Model-Based RL with Latent Dynamics\n",
    "\n",
    "Model-based reinforcement learning aims to improve sample efficiency by learning a model of the environment's dynamics. This learned model can then be used for planning, allowing the agent to \"simulate\" potential futures and choose actions without necessarily interacting with the real environment for every decision. PlaNet (Deep Planning Network) is a prominent example of this approach, particularly distinguished by its learning of dynamics within a compact *latent space*, often directly from high-dimensional observations like images.\n",
    "\n",
    "## What is PlaNet?\n",
    "\n",
    "PlaNet is a model-based RL agent that learns a world model from experience and uses this model to plan future actions. Its key innovation lies in learning the dynamics model not in the raw observation space (e.g., pixels), but in a lower-dimensional *latent space*. This makes learning the model more tractable and planning more efficient.\n",
    "\n",
    "The typical PlaNet architecture involves:\n",
    "1.  **Learning a World Model:** Training a model (often a Recurrent State-Space Model or RSSM) that can predict future latent states, rewards, and potentially reconstruct observations, given past latent states and actions.\n",
    "2.  **Planning in Latent Space:** Using the learned model to simulate future trajectories entirely within the compact latent space. An optimization algorithm, like the Cross-Entropy Method (CEM), is used to find the sequence of actions that maximizes the predicted cumulative reward over a planning horizon.\n",
    "3.  **Action Execution:** Executing only the *first* action of the best plan found by the planner in the real environment.\n",
    "4.  **Data Collection:** Storing the real observed transitions (observations, actions, rewards) in a replay buffer to continually improve the world model.\n",
    "\n",
    "### Core Idea: Learning Dynamics & Planning in Latent Space\n",
    "Instead of predicting how every pixel will change (which is very hard), PlaNet learns a compressed representation (latent state $s_t$) that captures the essential information needed to predict future states ($s_{t+1}$) and rewards ($r_t$). Planning then operates on these fast-to-simulate latent dynamics.\n",
    "\n",
    "## Why PlaNet? The Power of Learned Models & Planning\n",
    "\n",
    "- **High Sample Efficiency:** By leveraging the learned model for planning, PlaNet can often learn effective policies with significantly fewer real environment interactions compared to model-free methods, especially on complex tasks with high-dimensional observations.\n",
    "- **Handling Image Inputs:** Learning dynamics in a latent space makes it feasible to build world models directly from images, bypassing the need for hand-engineered state representations.\n",
    "- **Effective Planning:** Planning over future latent states allows the agent to anticipate consequences and choose actions that lead to high long-term rewards according to its learned model.\n",
    "\n",
    "## Where and How PlaNet is Used\n",
    "\n",
    "PlaNet and its successors (like DreamerV1/V2/V3) have shown state-of-the-art performance, particularly in:\n",
    "\n",
    "1.  **Control from Pixels:** Tasks where the input is images and actions are continuous (e.g., DeepMind Control Suite benchmarks).\n",
    "2.  **Robotics Simulation:** Learning complex manipulation and locomotion skills from visual input.\n",
    "3.  **Sample-Constrained Domains:** Situations where real-world interaction is expensive or time-consuming.\n",
    "\n",
    "## Mathematical Foundation of PlaNet\n",
    "\n",
    "### Latent Dynamics Model (Conceptual)\n",
    "PlaNet learns a model of the world, often structured as a Recurrent State-Space Model (RSSM), which typically includes:\n",
    "\n",
    "- **Transition Model ($p(s_{t+1} | s_t, a_t)$):** Predicts the distribution of the next latent state given the current latent state $s_t$ and action $a_t$. Often involves a deterministic recurrent component ($h_{t+1} = f(h_t, s_t, a_t)$) and a stochastic latent state $s_{t+1} \\sim p(s_{t+1} | h_{t+1})$.\n",
    "- **Reward Model ($p(r_t | s_t)$):** Predicts the distribution of the immediate reward given the latent state $s_t$.\n",
    "- **Observation Model ($p(o_t | s_t)$):** Predicts (reconstructs) the observation $o_t$ given the latent state $s_t$. Crucial for grounding the latent space when learning from images.\n",
    "- **Encoder / Representation Model ($q(s_t | ...)$):** Infers the latent state $s_t$ from observations $o_t$ and potentially past context ($h_t$). In variational approaches, this is often a posterior $q(s_t | h_t, o_t)$.\n",
    "\n",
    "*Simplification for this Notebook:* We will use simpler MLP-based models for transitions and rewards directly on the environment's vector state, effectively treating the vector state as (part of) the latent state and skipping the image encoding/decoding.\n",
    "\n",
    "### Model Training Objective\n",
    "The world model is trained by maximizing the likelihood of the observed data (sequences of observations, actions, rewards) stored in the replay buffer. This is often achieved by minimizing a loss function based on the Evidence Lower Bound (ELBO) in variational approaches, which typically includes:\n",
    "- **Reconstruction Loss:** Minimizing the difference between predicted observations $\\hat{o}_t$ (from $p(o_t | s_t)$) and actual observations $o_t$.\n",
    "- **Reward Prediction Loss:** Minimizing the difference between predicted rewards $\\hat{r}_t$ (from $p(r_t | s_t)$) and actual rewards $r_t$.\n",
    "- **KL Divergence Regularizers:** Penalizing the difference between the inferred posterior $q(s_t | h_t, o_t)$ and a learned prior $p(s_t | h_t)$, encouraging a well-structured latent space.\n",
    "\n",
    "*Simplification for this Notebook:* We will train our simplified dynamics model by minimizing the Mean Squared Error (MSE) for predicting the *next state vector* and the *reward*.\n",
    "$$ L_{model} = \\mathbb{E}_{(s_t, a_t, r_t, s_{t+1}) \\sim \\mathcal{D}} [ || s_{t+1} - \\hat{s}_{t+1}(s_t, a_t) ||^2 + || r_t - \\hat{r}_t(s_t, a_t) ||^2 ] $$\n",
    "where $\\hat{s}_{t+1}$ and $\\hat{r}_t$ are the predictions from our learned model.\n",
    "\n",
    "### Planning with the Model: Cross-Entropy Method (CEM)\n",
    "Given the current state $s_t$ (or its latent representation) and the learned model $(\\hat{p}(\\cdot | s, a), \\hat{r}(\\cdot, \\cdot))$, the goal is to find the sequence of actions $a_t, ..., a_{t+H-1}$ over a planning horizon $H$ that maximizes the expected cumulative reward predicted by the model: $\\mathbb{E} [ \\sum_{k=t}^{t+H-1} \\gamma^{k-t} \\hat{r}_k ]$.\n",
    "\n",
    "CEM is a derivative-free optimization algorithm used for this:\n",
    "1.  **Initialization:** Define an initial distribution over action sequences (e.g., Gaussian $\\mathcal{N}(\\mu, \\Sigma)$ for each step in the horizon).\n",
    "2.  **Sampling:** Sample $J$ candidate action sequences $A_j = (a_{t}^{(j)}, ..., a_{t+H-1}^{(j)})$ from the current distribution.\n",
    "3.  **Evaluation:** For each sequence $A_j$, use the learned dynamics model to simulate the trajectory in latent space and predict the total reward $R_j = \\sum_{k=t}^{t+H-1} \\gamma^{k-t} \\hat{r}_k^{(j)}$.\n",
    "4.  **Selection:** Select the top $M$ (elite) action sequences with the highest predicted rewards $R_j$.\n",
    "5.  **Refitting:** Update the parameters $(\\mu, \\Sigma)$ of the action sequence distribution based on the elite samples (e.g., compute the mean and variance of the elite sequences).\n",
    "6.  **Iteration:** Repeat steps 2-5 for a fixed number of iterations.\n",
    "7.  **Output:** The final mean $\\mu$ represents the best action sequence found. The first action $a_t = \\mu_t$ is executed.\n",
    "\n",
    "### Action Selection\n",
    "The action executed in the real environment at time $t$ is the first action $a_t^*$ from the best sequence found by the CEM planner: $a_t^* = \\text{Planner}(s_t, \\text{Model})$.\n",
    "\n",
    "## Step-by-Step Explanation of PlaNet\n",
    "\n",
    "1.  **Initialize**: Dynamics model (transition $\\hat{p}$, reward $\\hat{r}$), replay buffer $\\mathcal{D}$ (stores sequences). Hyperparameters (planning horizon $H$, CEM params $J, M$, model learning rate, etc.).\n",
    "2.  **Loop (Training Iterations/Environment Steps)**:\n",
    "    a.  **Interact & Collect Data**: \n",
    "        i.   Observe current state $s_t$.\n",
    "        ii.  Use CEM planner with the current model to find the best action sequence $a_t^*, ..., a_{t+H-1}^*$ starting from $s_t$.\n",
    "        iii. Execute the first action $a_t^*$ in the *real* environment.\n",
    "        iv.  Observe real reward $r_t$ and next state $s_{t+1}$.\n",
    "        v.   Store $(s_t, a_t^*, r_t, s_{t+1})$ in the replay buffer $\\mathcal{D}$.\n",
    "    b.  **Train World Model**: \n",
    "        i.   Sample a batch of sequences from $\\mathcal{D}$.\n",
    "        ii.  Train the dynamics model $(\\hat{p}, \\hat{r})$ to minimize the prediction loss (e.g., MSE for next state and reward) on the sampled sequences.\n",
    "    c.  $s_t \\leftarrow s_{t+1}$.\n",
    "3.  **Repeat**: Until convergence or max steps.\n",
    "\n",
    "## Key Components of PlaNet\n",
    "\n",
    "### World Model (Dynamics Model)\n",
    "- Learns to predict future states (latent or observed) and rewards from current state/latent state and action.\n",
    "- Trained on sequences of real experience.\n",
    "- Core component enabling planning.\n",
    "\n",
    "### Replay Buffer (Sequence-Based)\n",
    "- Stores sequences of transitions $(s_t, a_t, r_t, s_{t+1})$ or $(o_t, a_t, r_t, o_{t+1})$. Needed for training recurrent or sequence-based world models.\n",
    "\n",
    "### Model Training Procedure\n",
    "- Optimizes the world model parameters to accurately predict rewards and next states based on data from the replay buffer.\n",
    "\n",
    "### Planner (CEM)\n",
    "- Uses the learned world model to search for the optimal sequence of actions over a finite horizon $H$.\n",
    "- CEM is a common choice due to its simplicity and effectiveness in this context.\n",
    "\n",
    "### Action Execution\n",
    "- Only the first action from the planned sequence is executed in the real environment (Model Predictive Control principle).\n",
    "\n",
    "### Hyperparameters\n",
    "- Replay buffer size, batch size for model training.\n",
    "- Model learning rate, model architecture.\n",
    "- Planning horizon ($H$).\n",
    "- CEM parameters: iterations, candidates ($J$), elites ($M$), initial variance.\n",
    "\n",
    "## Practical Example: Pendulum Environment\n",
    "\n",
    "![Pendulum]()\n",
    "\n",
    "### Why Pendulum for this PlaNet Example?\n",
    "As mentioned, PlaNet typically uses image inputs. However, implementing the necessary vision components (CNNs) and latent models (RSSMs) is very complex for a didactic notebook. Pendulum provides a standard **continuous state and action space** where the benefits of model-based planning are still evident. We will adapt PlaNet to work with vector states, learning a model that predicts the next state vector $\\hat{s}_{t+1}$ and reward $\\hat{r}_t$ directly. This allows focusing on the interplay between model learning and CEM planning. **Requires `gymnasium`.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "Import libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import math\n",
    "from collections import namedtuple, deque\n",
    "from itertools import count\n",
    "from typing import List, Tuple, Dict, Optional, Callable, Any\n",
    "import copy\n",
    "import time\n",
    "\n",
    "# Import PyTorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal, Independent\n",
    "from torch.distributions.kl import kl_divergence\n",
    "\n",
    "# Import Gymnasium\n",
    "try:\n",
    "    import gymnasium as gym\n",
    "except ImportError:\n",
    "    print(\"Gymnasium not found. Please install using 'pip install gymnasium' or 'pip install gym[classic_control]'\")\n",
    "    gym = None\n",
    "\n",
    "# Set up device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Set random seeds\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Continuous Environment (Gymnasium)\n",
    "\n",
    "Instantiate Pendulum-v1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pendulum Environment:\n",
      "State Dim: 3\n",
      "Action Dim: 1\n",
      "Action Low: [-2.]\n",
      "Action High: [2.]\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the Pendulum environment\n",
    "if gym is not None:\n",
    "    try:\n",
    "        env = gym.make('Pendulum-v1')\n",
    "        env.reset(seed=seed)\n",
    "        env.action_space.seed(seed)\n",
    "\n",
    "        n_observations_planet = env.observation_space.shape[0]\n",
    "        n_actions_planet = env.action_space.shape[0]\n",
    "        action_low_planet = env.action_space.low\n",
    "        action_high_planet = env.action_space.high\n",
    "\n",
    "        print(f\"Pendulum Environment:\")\n",
    "        print(f\"State Dim: {n_observations_planet}\")\n",
    "        print(f\"Action Dim: {n_actions_planet}\")\n",
    "        print(f\"Action Low: {action_low_planet}\")\n",
    "        print(f\"Action High: {action_high_planet}\")\n",
    "    except Exception as e:\n",
    "        print(f\"Error creating Gymnasium environment: {e}\")\n",
    "        n_observations_planet = 3\n",
    "        n_actions_planet = 1\n",
    "        action_low_planet = np.array([-2.0])\n",
    "        action_high_planet = np.array([2.0])\n",
    "        env = None\n",
    "else:\n",
    "    print(\"Gymnasium not available. Cannot create Pendulum environment.\")\n",
    "    n_observations_planet = 3\n",
    "    n_actions_planet = 1\n",
    "    action_low_planet = np.array([-2.0])\n",
    "    action_high_planet = np.array([2.0])\n",
    "    env = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the PlaNet Algorithm\n",
    "\n",
    "Define the simplified dynamics model, sequence replay buffer, CEM planner, and training functions.\n",
    "\n",
    "### Defining the Dynamics Model (Simplified)\n",
    "\n",
    "An MLP that takes current state $s_t$ and action $a_t$ and predicts next state $s_{t+1}$ and reward $r_t$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DynamicsModel(nn.Module):\n",
    "    \"\"\" Simplified MLP-based dynamics model for PlaNet. \"\"\"\n",
    "    def __init__(self, state_dim: int, action_dim: int, hidden_dim: int = 200):\n",
    "        super(DynamicsModel, self).__init__()\n",
    "        self.state_dim = state_dim\n",
    "        self.action_dim = action_dim\n",
    "        \n",
    "        # Simple MLP architecture\n",
    "        self.fc1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        \n",
    "        # Output heads\n",
    "        self.fc_next_state = nn.Linear(hidden_dim, state_dim) # Predicts next state\n",
    "        self.fc_reward = nn.Linear(hidden_dim, 1)           # Predicts reward\n",
    "\n",
    "    def forward(self, state: torch.Tensor, action: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n",
    "        \"\"\"\n",
    "        Predicts the next state and reward.\n",
    "        \n",
    "        Parameters:\n",
    "        - state (torch.Tensor): Current state tensor.\n",
    "        - action (torch.Tensor): Action tensor.\n",
    "        \n",
    "        Returns:\n",
    "        - Tuple[torch.Tensor, torch.Tensor]:\n",
    "            - Predicted next state.\n",
    "            - Predicted reward.\n",
    "        \"\"\"\n",
    "        # Ensure inputs are 2D (batch_size, dim)\n",
    "        if state.dim() == 1: state = state.unsqueeze(0)\n",
    "        if action.dim() == 1: action = action.unsqueeze(0)\n",
    "        \n",
    "        x = torch.cat([state, action], dim=-1) # Concatenate state and action\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        \n",
    "        pred_next_state = self.fc_next_state(x)\n",
    "        pred_reward = self.fc_reward(x)\n",
    "        \n",
    "        # In a more complex model, might predict parameters of a distribution\n",
    "        # e.g., mean and variance for next state/reward.\n",
    "        # Here we just predict the mean directly.\n",
    "        \n",
    "        return pred_next_state, pred_reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Sequence Replay Buffer\n",
    "\n",
    "Stores sequences of transitions, needed for training sequence-based models (even our simplified MLP benefits from sequence context implicitly)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a transition structure for sequences\n",
    "# Store observations (o), actions (a), rewards (r), next_observations (o_next), dones (d)\n",
    "SeqTransition = namedtuple('SeqTransition',\n",
    "                           ('observations', 'actions', 'rewards', 'next_observations', 'dones'))\n",
    "\n",
    "class SequenceReplayBuffer:\n",
    "    \"\"\" Stores sequences of transitions. \"\"\"\n",
    "    def __init__(self, capacity: int, sequence_length: int):\n",
    "        self.capacity = capacity\n",
    "        self.sequence_length = sequence_length\n",
    "        self.buffer: List[Tuple[Any, ...]] = [] # Stores individual (o, a, r, o_next, d) steps\n",
    "        self.position = 0\n",
    "\n",
    "    def push(self, obs: np.ndarray, action: np.ndarray, reward: float, next_obs: np.ndarray, done: bool) -> None:\n",
    "        \"\"\" Add a single step transition to the buffer. \"\"\"\n",
    "        # Convert to numpy for storage efficiency if needed, or keep as tensors\n",
    "        transition = (obs, action, reward, next_obs, float(done)) \n",
    "        if len(self.buffer) < self.capacity:\n",
    "            self.buffer.append(None)\n",
    "        self.buffer[self.position] = transition\n",
    "        self.position = (self.position + 1) % self.capacity\n",
    "\n",
    "    def sample(self, batch_size: int) -> Optional[SeqTransition]:\n",
    "        \"\"\" Sample a batch of sequences. \"\"\"\n",
    "        if len(self.buffer) < self.sequence_length:\n",
    "            return None # Not enough data to form a sequence\n",
    "            \n",
    "        observations_batch = []\n",
    "        actions_batch = []\n",
    "        rewards_batch = []\n",
    "        next_observations_batch = []\n",
    "        dones_batch = []\n",
    "\n",
    "        for _ in range(batch_size):\n",
    "            # Choose a random starting point for the sequence\n",
    "            start_idx = random.randint(0, len(self.buffer) - self.sequence_length)\n",
    "            sequence = self.buffer[start_idx : start_idx + self.sequence_length]\n",
    "            \n",
    "            # Unzip the sequence\n",
    "            obs_seq, act_seq, rew_seq, next_obs_seq, done_seq = zip(*sequence)\n",
    "            \n",
    "            observations_batch.append(np.array(obs_seq))\n",
    "            actions_batch.append(np.array(act_seq))\n",
    "            rewards_batch.append(np.array(rew_seq))\n",
    "            next_observations_batch.append(np.array(next_obs_seq))\n",
    "            dones_batch.append(np.array(done_seq))\n",
    "\n",
    "        # Convert lists of sequences to tensors (batch_size, seq_len, feature_dim)\n",
    "        obs_tensor = torch.from_numpy(np.array(observations_batch)).float().to(device)\n",
    "        act_tensor = torch.from_numpy(np.array(actions_batch)).float().to(device)\n",
    "        rew_tensor = torch.from_numpy(np.array(rewards_batch)).float().to(device).unsqueeze(-1) # Add feature dim\n",
    "        next_obs_tensor = torch.from_numpy(np.array(next_observations_batch)).float().to(device)\n",
    "        dones_tensor = torch.from_numpy(np.array(dones_batch)).float().to(device).unsqueeze(-1) # Add feature dim\n",
    "\n",
    "        return SeqTransition(obs_tensor, act_tensor, rew_tensor, next_obs_tensor, dones_tensor)\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing the CEM Planner\n",
    "\n",
    "A function that performs CEM planning using the learned dynamics model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cem_planner(model: DynamicsModel, \n",
    "                initial_state: torch.Tensor, \n",
    "                horizon: int, \n",
    "                num_candidates: int, \n",
    "                num_elites: int, \n",
    "                num_iterations: int,\n",
    "                gamma: float, \n",
    "                action_low: np.ndarray, \n",
    "                action_high: np.ndarray,\n",
    "                action_dim: int) -> torch.Tensor:\n",
    "    \"\"\"\n",
    "    Performs Cross-Entropy Method (CEM) planning using the dynamics model.\n",
    "\n",
    "    Parameters:\n",
    "    - model: The learned DynamicsModel.\n",
    "    - initial_state: The state from which to start planning.\n",
    "    - horizon: Planning horizon (number of steps H).\n",
    "    - num_candidates: Number of action sequences to sample (J).\n",
    "    - num_elites: Number of top sequences to keep (M).\n",
    "    - num_iterations: Number of CEM refinement iterations.\n",
    "    - gamma: Discount factor for simulated rewards.\n",
    "    - action_low, action_high: Action space bounds.\n",
    "    - action_dim: Dimension of the action space.\n",
    "\n",
    "    Returns:\n",
    "    - torch.Tensor: The first action of the best sequence found.\n",
    "    \"\"\"\n",
    "    model.eval() # Set model to evaluation mode for planning\n",
    "\n",
    "    # Initialize action distribution (Gaussian)\n",
    "    # Mean initialized to zeros, std dev initialized to cover half the action range\n",
    "    action_mean = torch.zeros(horizon, action_dim, device=device)\n",
    "    action_std_dev = torch.ones(horizon, action_dim, device=device) * (torch.from_numpy(action_high - action_low).float().to(device) / 2.0)\n",
    "\n",
    "    for _ in range(num_iterations):\n",
    "        # Sample candidate action sequences from the current distribution\n",
    "        # Shape: (num_candidates, horizon, action_dim)\n",
    "        action_dist = Normal(action_mean, action_std_dev)\n",
    "        candidate_actions = action_dist.sample((num_candidates,))\n",
    "        \n",
    "        # Clip actions to bounds\n",
    "        action_low_t = torch.from_numpy(action_low).float().to(device)\n",
    "        action_high_t = torch.from_numpy(action_high).float().to(device)\n",
    "        candidate_actions = torch.clamp(candidate_actions, action_low_t, action_high_t)\n",
    "\n",
    "        # Evaluate candidate sequences using the model\n",
    "        total_rewards = torch.zeros(num_candidates, device=device)\n",
    "        current_states = initial_state.repeat(num_candidates, 1) # Start all candidates from initial state\n",
    "\n",
    "        with torch.no_grad(): # No gradients needed during model rollout\n",
    "            for t in range(horizon):\n",
    "                actions_t = candidate_actions[:, t, :] # Actions for this time step\n",
    "                # Predict next state and reward using the model\n",
    "                next_states, rewards = model(current_states, actions_t)\n",
    "                total_rewards += (gamma ** t) * rewards.squeeze() # Accumulate discounted reward\n",
    "                current_states = next_states # Move to predicted next state\n",
    "\n",
    "        # Select elite action sequences\n",
    "        _, elite_indices = torch.topk(total_rewards, num_elites) # Get indices of top M sequences\n",
    "        elite_actions = candidate_actions[elite_indices]\n",
    "        \n",
    "        # Refit the action distribution to the elite samples\n",
    "        action_mean = elite_actions.mean(dim=0)\n",
    "        action_std_dev = elite_actions.std(dim=0) + 1e-6 # Add epsilon for stability\n",
    "\n",
    "    # Return the mean of the first action in the final distribution\n",
    "    best_first_action = action_mean[0]\n",
    "    return best_first_action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Training Function\n",
    "\n",
    "Trains the dynamics model using sampled sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model: DynamicsModel, \n",
    "                model_optimizer: optim.Optimizer, \n",
    "                replay_buffer: SequenceReplayBuffer, \n",
    "                batch_size: int, \n",
    "                num_train_steps: int) -> float:\n",
    "    \"\"\"\n",
    "    Trains the dynamics model for a number of steps.\n",
    "    \n",
    "    Parameters:\n",
    "    - model: The DynamicsModel to train.\n",
    "    - model_optimizer: The optimizer for the model.\n",
    "    - replay_buffer: The sequence buffer to sample from.\n",
    "    - batch_size: The number of sequences per batch.\n",
    "    - num_train_steps: The number of gradient steps to perform.\n",
    "    \n",
    "    Returns:\n",
    "    - float: The average loss over the training steps.\n",
    "    \"\"\"\n",
    "    model.train() # Set model to training mode\n",
    "    total_loss = 0.0\n",
    "    steps_done = 0\n",
    "\n",
    "    for _ in range(num_train_steps):\n",
    "        # Sample a batch of sequences\n",
    "        sequence_batch = replay_buffer.sample(batch_size)\n",
    "        if sequence_batch is None:\n",
    "            continue # Not enough data yet\n",
    "            \n",
    "        obs_batch, act_batch, rew_batch, next_obs_batch, dones_batch = sequence_batch\n",
    "        # obs_batch shape: (batch_size, seq_len, state_dim)\n",
    "        # act_batch shape: (batch_size, seq_len, action_dim)\n",
    "        # rew_batch shape: (batch_size, seq_len, 1)\n",
    "        # next_obs_batch shape: (batch_size, seq_len, state_dim)\n",
    "\n",
    "        # --- Calculate Model Loss --- \n",
    "        # We need to predict next_state and reward for each step in the sequence.\n",
    "        # Here, we simplify and just predict based on the first step of each sequence \n",
    "        # for demonstration. A proper implementation would iterate through the sequence\n",
    "        # or use an RNN within the model.\n",
    "        \n",
    "        current_states = obs_batch[:, 0, :] # State at the start of sequence\n",
    "        current_actions = act_batch[:, 0, :] # Action at the start of sequence\n",
    "        target_next_states = next_obs_batch[:, 0, :] # True next state\n",
    "        target_rewards = rew_batch[:, 0, :]      # True reward\n",
    "\n",
    "        # Get model predictions\n",
    "        pred_next_states, pred_rewards = model(current_states, current_actions)\n",
    "        \n",
    "        # Calculate MSE losses\n",
    "        state_loss = F.mse_loss(pred_next_states, target_next_states)\n",
    "        reward_loss = F.mse_loss(pred_rewards, target_rewards)\n",
    "        \n",
    "        # Combine losses (can add weights if needed)\n",
    "        loss = state_loss + reward_loss\n",
    "        \n",
    "        # --- Optimize Model --- \n",
    "        model_optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        # Optional: Gradient clipping\n",
    "        # torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) \n",
    "        model_optimizer.step()\n",
    "        \n",
    "        total_loss += loss.item()\n",
    "        steps_done += 1\n",
    "\n",
    "    return total_loss / steps_done if steps_done > 0 else 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the PlaNet Algorithm\n",
    "\n",
    "Set up hyperparameters, initialize components, and run the main PlaNet loop.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "Define hyperparameters for PlaNet and CEM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for PlaNet on Pendulum-v1\n",
    "BUFFER_CAPACITY_PLANET = int(1e5)   # Buffer stores individual steps\n",
    "SEQUENCE_LENGTH = 50              # Length of sequences sampled for model training\n",
    "MODEL_BATCH_SIZE = 32             # Number of sequences per model training batch\n",
    "MODEL_TRAIN_STEPS = 100           # Gradient steps for model per iteration\n",
    "MODEL_LR = 1e-3                   # Learning rate for the dynamics model\n",
    "HIDDEN_DIM_MODEL = 200            # Hidden dimension for the dynamics model\n",
    "\n",
    "# CEM Planner Hyperparameters\n",
    "PLANNING_HORIZON = 12             # How many steps ahead to plan (H)\n",
    "CEM_CANDIDATES = 1000             # Candidates sampled per CEM iteration (J)\n",
    "CEM_ELITES = 100                  # Elite samples to keep per CEM iteration (M)\n",
    "CEM_ITERATIONS = 10               # Number of CEM refinement iterations\n",
    "CEM_GAMMA = 0.99                  # Discount factor used *during planning*\n",
    "\n",
    "# Training Loop Hyperparameters\n",
    "NUM_ITERATIONS_PLANET = 50       # Number of Collect/Train iterations\n",
    "STEPS_PER_ITERATION_PLANET = 100  # Environment steps collected per iteration\n",
    "INITIAL_RANDOM_STEPS = 1000       # Collect initial data randomly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization\n",
    "\n",
    "Initialize model, optimizer, and replay buffer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting 1000 initial random steps...\n",
      "Initial data collection complete.\n"
     ]
    }
   ],
   "source": [
    "if env is None:\n",
    "    raise RuntimeError(\"Gymnasium environment 'Pendulum-v1' could not be created.\")\n",
    "\n",
    "# Initialize Dynamics Model\n",
    "dynamics_model = DynamicsModel(n_observations_planet, \n",
    "                               n_actions_planet, \n",
    "                               HIDDEN_DIM_MODEL).to(device)\n",
    "\n",
    "# Initialize Model Optimizer\n",
    "model_optimizer = optim.Adam(dynamics_model.parameters(), lr=MODEL_LR)\n",
    "\n",
    "# Initialize Replay Buffer\n",
    "replay_buffer = SequenceReplayBuffer(BUFFER_CAPACITY_PLANET, SEQUENCE_LENGTH)\n",
    "\n",
    "# Lists for plotting\n",
    "planet_iteration_rewards = []\n",
    "planet_iteration_model_losses = []\n",
    "\n",
    "# --- Collect Initial Random Data --- \n",
    "print(f\"Collecting {INITIAL_RANDOM_STEPS} initial random steps...\")\n",
    "obs_np, _ = env.reset()\n",
    "for _ in range(INITIAL_RANDOM_STEPS):\n",
    "    action_np = env.action_space.sample()\n",
    "    next_obs_np, reward, terminated, truncated, _ = env.step(action_np)\n",
    "    done = terminated or truncated\n",
    "    replay_buffer.push(obs_np, action_np, reward, next_obs_np, done)\n",
    "    obs_np = next_obs_np\n",
    "    if done:\n",
    "        obs_np, _ = env.reset()\n",
    "print(\"Initial data collection complete.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop\n",
    "\n",
    "The PlaNet loop: Collect data using CEM planning, then train the world model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting PlaNet Training on Pendulum-v1...\n",
      "Iter 10/50 | Steps: 1000 | Avg Ep Reward: -492.32 | Model Loss: 0.040212\n",
      "Iter 20/50 | Steps: 2000 | Avg Ep Reward: -267.97 | Model Loss: 0.006726\n",
      "Iter 30/50 | Steps: 3000 | Avg Ep Reward: -519.70 | Model Loss: 0.004455\n",
      "Iter 40/50 | Steps: 4000 | Avg Ep Reward: -151.99 | Model Loss: 0.003335\n",
      "Iter 50/50 | Steps: 5000 | Avg Ep Reward: -0.64 | Model Loss: 0.002298\n",
      "Pendulum-v1 Training Finished (PlaNet).\n"
     ]
    }
   ],
   "source": [
    "print(\"Starting PlaNet Training on Pendulum-v1...\")\n",
    "\n",
    "# --- PlaNet Training Loop ---\n",
    "total_steps_planet = 0\n",
    "current_state_np, _ = env.reset()\n",
    "current_state = torch.from_numpy(current_state_np).float().to(device)\n",
    "\n",
    "for iteration in range(1, NUM_ITERATIONS_PLANET + 1):\n",
    "    # --- 1. Collect Data using Planner --- \n",
    "    iteration_rewards_list = []\n",
    "    current_episode_reward = 0.0\n",
    "    steps_this_iter = 0\n",
    "    \n",
    "    while steps_this_iter < STEPS_PER_ITERATION_PLANET:\n",
    "        # Plan action using CEM\n",
    "        action_tensor = cem_planner(\n",
    "            dynamics_model,\n",
    "            current_state,\n",
    "            horizon=PLANNING_HORIZON,\n",
    "            num_candidates=CEM_CANDIDATES,\n",
    "            num_elites=CEM_ELITES,\n",
    "            num_iterations=CEM_ITERATIONS,\n",
    "            gamma=CEM_GAMMA, # Use planning discount\n",
    "            action_low=action_low_planet,\n",
    "            action_high=action_high_planet,\n",
    "            action_dim=n_actions_planet\n",
    "        )\n",
    "        action_np = action_tensor.detach().cpu().numpy()\n",
    "        # Clip just in case CEM produces values slightly out of bounds\n",
    "        action_np_clipped = np.clip(action_np, action_low_planet, action_high_planet)\n",
    "\n",
    "        # Interact with environment\n",
    "        next_state_np, reward, terminated, truncated, _ = env.step(action_np_clipped)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # Store experience\n",
    "        replay_buffer.push(current_state_np, action_np_clipped, reward, next_state_np, done)\n",
    "        \n",
    "        current_state_np = next_state_np\n",
    "        current_state = torch.from_numpy(current_state_np).float().to(device)\n",
    "        current_episode_reward += reward\n",
    "        total_steps_planet += 1\n",
    "        steps_this_iter += 1\n",
    "        \n",
    "        if done:\n",
    "            iteration_rewards_list.append(current_episode_reward)\n",
    "            current_state_np, _ = env.reset()\n",
    "            current_state = torch.from_numpy(current_state_np).float().to(device)\n",
    "            current_episode_reward = 0.0\n",
    "            # Check if iteration step limit reached even if episode ended early\n",
    "            if steps_this_iter >= STEPS_PER_ITERATION_PLANET:\n",
    "                break\n",
    "                \n",
    "    # --- 2. Train World Model --- \n",
    "    avg_model_loss = train_model(dynamics_model, model_optimizer, replay_buffer,\n",
    "                                 MODEL_BATCH_SIZE, MODEL_TRAIN_STEPS)\n",
    "\n",
    "    # --- Logging --- \n",
    "    avg_iter_reward = np.mean(iteration_rewards_list) if iteration_rewards_list else np.nan\n",
    "    planet_iteration_rewards.append(avg_iter_reward)\n",
    "    planet_iteration_model_losses.append(avg_model_loss)\n",
    "    \n",
    "    if iteration % 10 == 0:\n",
    "        print(f\"Iter {iteration}/{NUM_ITERATIONS_PLANET} | Steps: {total_steps_planet} | Avg Ep Reward: {avg_iter_reward:.2f} | Model Loss: {avg_model_loss:.6f}\")\n",
    "\n",
    "print(\"Pendulum-v1 Training Finished (PlaNet).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Learning Process\n",
    "\n",
    "Plot average episode rewards per iteration and the model training loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for PlaNet on Pendulum-v1\n",
    "plt.figure(figsize=(12, 4))\n",
    "\n",
    "# Average Episode Rewards per Iteration\n",
    "plt.subplot(1, 2, 1)\n",
    "valid_rewards_planet = [r for r in planet_iteration_rewards if not np.isnan(r)]\n",
    "valid_indices_planet = [i for i, r in enumerate(planet_iteration_rewards) if not np.isnan(r)]\n",
    "plt.plot(valid_indices_planet, valid_rewards_planet)\n",
    "plt.title('PlaNet Pendulum: Avg Episode Reward / Iteration')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Avg Reward')\n",
    "plt.grid(True)\n",
    "if len(valid_rewards_planet) >= 10:\n",
    "    rewards_ma_planet = np.convolve(valid_rewards_planet, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(valid_indices_planet[9:], rewards_ma_planet, label='10-iter MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Model Loss per Iteration\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(planet_iteration_model_losses)\n",
    "plt.title('PlaNet Pendulum: Avg Model Loss / Iteration')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Avg MSE Loss (State+Reward)')\n",
    "plt.yscale('log') # Loss often decreases significantly, log scale helps\n",
    "plt.grid(True, which='both')\n",
    "if len(planet_iteration_model_losses) >= 10:\n",
    "    mloss_ma_planet = np.convolve(planet_iteration_model_losses, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(mloss_ma_planet)) + 9, mloss_ma_planet, label='10-iter MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of PlaNet Learning Curves (Pendulum):**\n",
    "\n",
    "1.  **Avg Episode Reward / Iteration (Left Plot):**\n",
    "    *   **Observation:** This plot shows an extremely rapid initial phase of learning. Starting from very poor performance (~-800), the average reward shoots up dramatically within the first 15-20 iterations, reaching values close to the optimal range (approaching 0). Following this steep ascent, the reward exhibits significant instability, with large oscillations between near-optimal performance and much lower rewards (-400 or worse). The 10-iteration moving average (orange line) captures the overall high level achieved after the initial learning but smooths over these pronounced peaks and troughs.\n",
    "    *   **Interpretation:** The rapid initial improvement highlights the potential sample efficiency of PlaNet. By learning a dynamics model, it can quickly leverage simulated experience (\"planning\") to find decent policies with relatively few real environment interactions. The subsequent volatility, however, is crucial. It suggests that while the learned model is good enough for initial progress, it likely contains inaccuracies. The planner (CEM in PlaNet) might find action sequences that yield high rewards *according to the imperfect model*, but these plans don't perfectly translate to the real environment, leading to performance drops. This discrepancy between model-based plans and real-world outcomes causes the observed oscillations.\n",
    "\n",
    "2.  **Avg Model Loss / Iteration (Right Plot):**\n",
    "    *   **Observation:** This plot shows the average Mean Squared Error (MSE) loss for the world model's predictions (next state and reward) on a logarithmic scale. The loss decreases very rapidly by several orders of magnitude during the first ~15 iterations, corresponding precisely with the period of fastest reward improvement. After this initial drop, the loss stabilizes at a low average value (around 0.01-0.02), with some minor fluctuations later in training.\n",
    "    *   **Interpretation:** The sharp initial decrease confirms that the world model component of PlaNet is learning effectively and quickly capturing the short-term dynamics of the Pendulum environment from the collected experience. This ability to quickly build a reasonably predictive model is what enables the fast initial policy improvement seen in the reward plot. The stabilization indicates the model has reached a certain level of accuracy, likely limited by the complexity of the dynamics, the model capacity, and the quality/diversity of the collected data. Even a low average loss doesn't guarantee perfect long-term predictions, which is essential for the multi-step planning phase.\n",
    "\n",
    "**Overall Conclusion:**\n",
    "PlaNet demonstrates impressive initial sample efficiency on the Pendulum task, rapidly improving rewards by learning a predictive world model and planning using it. The model loss converges quickly to low values, indicating good short-term prediction capabilities. However, the pronounced volatility in rewards after the initial learning phase suggests that inaccuracies in the learned model are amplified by the multi-step planning process (CEM). This leads to plans that are optimal within the learned model but suboptimal or unstable when executed in the true environment, highlighting the challenge of model bias in model-based reinforcement learning, especially for continuous control tasks requiring precise long-horizon predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing the Learned Policy (Testing)\n",
    "\n",
    "Visualize the performance of the PlaNet agent by running it in the environment, using the planner at each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Testing PlaNet Agent (3 episodes) ---\n",
      "Test Episode 1: Reward = -1765.54, Length = 200\n",
      "Test Episode 2: Reward = -4.07, Length = 200\n",
      "Test Episode 3: Reward = -392.67, Length = 200\n",
      "--- Testing Complete. Average Reward: -720.76 ---\n"
     ]
    }
   ],
   "source": [
    "def test_planet_agent(model: DynamicsModel, \n",
    "                      env_instance: gym.Env, \n",
    "                      num_episodes: int = 5, \n",
    "                      render: bool = False, \n",
    "                      seed_offset: int = 3000, \n",
    "                      cem_params: dict = {}) -> None:\n",
    "    \"\"\"\n",
    "    Tests the trained PlaNet agent using CEM planning at each step.\n",
    "    \"\"\"\n",
    "    if env_instance is None:\n",
    "        print(\"Environment not available for testing.\")\n",
    "        return\n",
    "        \n",
    "    model.eval() # Set model to evaluation mode\n",
    "    \n",
    "    # Get CEM params or use defaults\n",
    "    horizon = cem_params.get('horizon', PLANNING_HORIZON)\n",
    "    candidates = cem_params.get('candidates', CEM_CANDIDATES)\n",
    "    elites = cem_params.get('elites', CEM_ELITES)\n",
    "    iterations = cem_params.get('iterations', CEM_ITERATIONS)\n",
    "    gamma = cem_params.get('gamma', CEM_GAMMA)\n",
    "    action_dim = env_instance.action_space.shape[0]\n",
    "    action_low = env_instance.action_space.low\n",
    "    action_high = env_instance.action_space.high\n",
    "\n",
    "    print(f\"\\n--- Testing PlaNet Agent ({num_episodes} episodes) ---\")\n",
    "    all_rewards = []\n",
    "    for i in range(num_episodes):\n",
    "        state_np, info = env_instance.reset(seed=seed + seed_offset + i)\n",
    "        state = torch.from_numpy(state_np).float().to(device)\n",
    "        episode_reward = 0\n",
    "        done = False\n",
    "        t = 0\n",
    "        while not done:\n",
    "            if render:\n",
    "                try:\n",
    "                    env_instance.render()\n",
    "                    time.sleep(0.01)\n",
    "                except Exception as e:\n",
    "                    print(f\"Rendering failed: {e}. Disabling render.\")\n",
    "                    render = False\n",
    "            \n",
    "            # Plan action using CEM\n",
    "            action_tensor = cem_planner(\n",
    "                model, state, horizon, candidates, elites, iterations, gamma,\n",
    "                action_low, action_high, action_dim\n",
    "            )\n",
    "            action_np = action_tensor.detach().cpu().numpy()\n",
    "            action_np_clipped = np.clip(action_np, action_low, action_high)\n",
    "            \n",
    "            # Step environment\n",
    "            next_state_np, reward, terminated, truncated, _ = env_instance.step(action_np_clipped)\n",
    "            done = terminated or truncated\n",
    "            state = torch.from_numpy(next_state_np).float().to(device)\n",
    "            episode_reward += reward\n",
    "            t += 1\n",
    "        \n",
    "        print(f\"Test Episode {i+1}: Reward = {episode_reward:.2f}, Length = {t}\")\n",
    "        all_rewards.append(episode_reward)\n",
    "        if render:\n",
    "             env_instance.close()\n",
    "\n",
    "    print(f\"--- Testing Complete. Average Reward: {np.mean(all_rewards):.2f} ---\")\n",
    "\n",
    "# Run test episodes (ensure env is still available)\n",
    "# Pass CEM parameters used during training (or potentially refined ones)\n",
    "test_cem_params = {\n",
    "    'horizon': PLANNING_HORIZON,\n",
    "    'candidates': CEM_CANDIDATES,\n",
    "    'elites': CEM_ELITES,\n",
    "    'iterations': CEM_ITERATIONS,\n",
    "    'gamma': CEM_GAMMA\n",
    "}\n",
    "test_planet_agent(dynamics_model, env, num_episodes=3, render=False, cem_params=test_cem_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Extensions of PlaNet\n",
    "\n",
    "**Challenge: Model Accuracy vs. Complexity**\n",
    "*   **Problem:** Learning an accurate world model, especially from high-dimensional data like images or for complex dynamics, is inherently difficult. Simple models might be inaccurate, while complex models (like full RSSMs) are hard to train and computationally expensive.\n",
    "*   **Solutions**:\n",
    "    *   **Better Model Architectures:** Using more sophisticated sequence models (RSSM, Transformers) designed for dynamics modeling.\n",
    "    *   **Probabilistic Models:** Predicting distributions over next states/rewards captures uncertainty.\n",
    "    *   **Careful Regularization:** Techniques like KL regularization in variational models help structure the latent space.\n",
    "    *   **Focus on Relevant Information:** Design models to predict only what's necessary for planning.\n",
    "\n",
    "**Challenge: Compounding Model Errors**\n",
    "*   **Problem:** During planning (simulating over horizon $H$), small prediction errors at each step can accumulate, leading to inaccurate long-term predictions and potentially poor plans.\n",
    "*   **Solutions**:\n",
    "    *   **Shorter Planning Horizon ($H$):** Reduces the potential for error accumulation but might lead to myopic behavior.\n",
    "    *   **More Accurate Models:** Improving the single-step prediction accuracy.\n",
    "    *   **Model Ensemble:** Train multiple models and average their predictions during planning.\n",
    "    * **Re-planning:** Frequently re-plan from the current *real* state to correct for deviations.\n",
    "\n",
    "**Challenge: Planning Cost**\n",
    "*   **Problem:** Performing iterative optimization like CEM at every time step can be computationally expensive, limiting real-time application.\n",
    "   **Solutions**:\n",
    "    *   **Efficient Planners:** Investigate faster planning algorithms (e.g., gradient-based trajectory optimization if the model is differentiable, or optimized CEM implementations).\n",
    "    *   **Reduce CEM Parameters:** Decrease candidates ($J$), elites ($M$), or iterations, trading off planning quality for speed.\n",
    "    *   **Plan Less Frequently:** Execute multiple actions from a single plan before re-planning.\n",
    "    *   **Amortized Planning (Policy Learning):** Train a separate policy network (actor) using the planner's outputs as targets (as done in later algorithms like Dreamer), effectively distilling the planning computation into a fast policy network.\n",
    "\n",
    "**Challenge: Discrepancy between Model and Reality (Sim-to-Real Gap)**\n",
    "*   **Problem:** Even a well-trained model is an approximation. Policies optimized entirely within the model might not transfer perfectly to the real world.\n",
    "*   **Solutions**:\n",
    "    *   **Continuous Model Updates:** Keep training the model with new real data.\n",
    "    *   **Robust Planning:** Use techniques that account for model uncertainty during planning.\n",
    "    *   **System Identification:** Techniques to explicitly improve model accuracy in relevant parts of the state space.\n",
    "\n",
    "**Extensions (Dreamer Family):**\n",
    "- **DreamerV1/V2/V3:** Successors to PlaNet that build upon the core ideas. They typically use more advanced RSSMs, learn policy and value functions *within the latent space* using imagined trajectories, and often achieve even higher sample efficiency and performance.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "PlaNet represents a powerful paradigm in model-based reinforcement learning, demonstrating the potential of learning world models, particularly in latent space, and leveraging them for planning. By decoupling model learning from policy execution, it aims for high sample efficiency, making it suitable for complex tasks, especially those with high-dimensional observations like images.\n",
    "\n",
    "The core loop involves collecting experience, training the latent dynamics model (predicting states and rewards), and using a planner like CEM to find optimal action sequences based on the model's simulations. While facing challenges related to model accuracy, compounding errors, and planning cost, PlaNet's approach of planning in a learned latent space has been highly influential, paving the way for subsequent state-of-the-art algorithms like the Dreamer series."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
